…eaming chunk delivery

A terminal band failure on a chunk-streaming sharded pull no longer cancels the sibling bands: they drain to completion, and the call returns the new Error::PartialShardFetch naming the failed band window(s) so the caller can re-pull exactly the missing slices instead of restarting the whole pull. A pull where no chunk reached the handler still fails wholesale with the underlying error, a band that fails before delivering anything still retries transparently, and the call deadline still cancels every band at once. The buffered path's per-band from-scratch re-fetch (attempt-local collection, dedup-free replay) is documented and pinned by tests. The new variant maps to StreamError / THETADATADX_ERR_STREAM across the Python, TypeScript, and C surfaces.

The four dedicated *_stream builders now drain through MarketDataClient::deliver_chunk_slices, the same primitive the generated .stream(handler) methods use, so both public surfaces of one endpoint agree on the no-replay delivered gating (marked only when rows reach the handler, keeping a recoverable transient after empty keepalives retryable) and stop at the first decode failure; the divergent for_each_chunk_body template is deleted.

The planner now logs at debug why a query did not shard (unlisted endpoint, no cut axis, width under two, malformed window, provably small grid, narrow window), and each band future runs inside a shard_band tracing span carrying its window plus a per-band completion line with rows and duration, so concurrent bands stay distinguishable in the log stream.

The shardable-endpoint set is now a const roster asserted equal to the registry's intraday-history endpoints (history* subcategory carrying start_time/end_time filters), so a new intraday history endpoint cannot silently never-shard. A new integration suite drives sharded pulls end-to-end through a per-band scripted mock, buffered and streaming: fan-out shape, band-order merge, NotFound folding, buffered band re-fetch, pre-delivery streaming retry, and the streaming partial-fetch error.

Whole-market as-of queries (stock/index at_time) return one row per day and are dominated by per-day server compute, not transfer. Banding the requested date range runs those per-day lookups concurrently over the tier's channel pool, so a wide as-of pull drops from a single stream to a fraction of its wall time (a one-year stock pull measured ~188s to ~18s at Pro width) with byte-identical, date-ordered output.

Add stock_at_time_trade, stock_at_time_quote and index_at_time_price to the shardable set, reusing the existing date-axis planner and ordered merge with no new axis. The set stays machine-tied to the registry: the tie now derives intraday history (history* with start_time/end_time) plus whole-market at_time (at_time subcategory, category not option). Single-contract option at_time carries a contract identity and is sparse over a wide range, so it stays single-stream.

The server computes at_time per day independently, with no last-tick carry across days (a pre-open time_of_day yields NotFound, not the prior close), so a date band seam cannot diverge from the single stream; verified against single-stream output value-for-value. Multi-day at_time .stream() now fans out, so its chunks arrive interleaved across bands rather than strictly date-ascending, matching every other sharded history stream.

Tests pin the plan (whole-market at_time to N date bands; option at_time and daily-only families decline) and the uncatchable residual (a concrete-contract tick over-shard is invisible to request shape).

An option-chain pull (strike wildcard) is a contract cross-product, and its cost is the server enumerating those contracts, not transfer. Slicing the requested window by time made every band re-enumerate the whole chain; splitting by right (call / put) instead makes each band assemble half the contracts. A both-rights chain now fans out into a call half and a put half, and the tier's remaining lanes slice each half by time (at Pro width 8, call x 4 time bands + put x 4), so the fan-out fills the tier's concurrency with work that divides the bottleneck rather than multiplying it.

The plan emits all-calls-then-all-puts, each half in time order. The ordered merge groups rows by (expiration, strike, right) and keeps band order within a contract, so it interleaves call before put within each strike and stays time-ascending — the exact single-stream canonical order, independent of the right x time split. Buffered output is therefore unchanged. A single-right chain (a strike wildcard already pinned to call or put) has nothing to divide on this axis and keeps the equal time split; a chain over a window too narrow for a time split still fans out into a plain call/put pair.

ShardBand::Time carries an optional right override applied per band through shard_apply_field, so both the buffered and streaming fan-outs pick it up. Tests pin the plan (both-rights chain -> call/put x time bands; single-right chain -> time-only; narrow concrete contract -> decline) and the merge (call/put x time bands reassemble into canonical contract order).

A `*` option chain at_time — every strike as-of a time, each day — is a dense per-day-compute pull that bands across a date range exactly like the whole-market stock and index at_time already do, but it was excluded along with the concrete single-contract case. Admit option_at_time_trade and option_at_time_quote to the shardable set and decline only the concrete contract (sparse, ~1 row/day) at runtime, so a chain shards and a single contract still runs on one stream.

Reuses the existing date-band and ChainKey merge that already serve multi-day history chains, so no new machinery is added. Date bands reproduce the single-stream row set, including at a carry-sensitive as-of time: an option's prior-day carry resolves from the calendar day before the pull, not from a band's start date, so band seams never diverge.